Face Generation¶

In this project, you'll use generative adversarial networks to generate new images of faces.

Get the Data¶

You'll be using two datasets in this project:

MNIST
CelebA

Since the celebA dataset is complex and you're doing GANs in a project for the first time, we want you to test your neural network on MNIST before CelebA. Running the GANs on MNIST will allow you to see how well your model trains sooner.

If you're using FloydHub, set data_dir to "/input" and use the FloydHub data ID "R5KrjnANiKVhLWAkpXhNBe".

#data_dir = './data'

# FloydHub - Use with data ID "R5KrjnANiKVhLWAkpXhNBe"
data_dir = '/input'


"""
DON'T MODIFY ANYTHING IN THIS CELL
"""
import helper

helper.download_extract('mnist', data_dir)
helper.download_extract('celeba', data_dir)

Downloading mnist: 9.92MB [00:01, 7.23MB/s]                            
Extracting mnist: 100%|██████████| 60.0K/60.0K [00:11<00:00, 5.22KFile/s]
Downloading celeba: 1.44GB [00:37, 38.2MB/s]

Extracting celeba...

Explore the Data¶

MNIST¶

As you're aware, the MNIST dataset contains images of handwritten digits. You can view the first number of examples by changing show_n_images.

show_n_images = 25

"""
DON'T MODIFY ANYTHING IN THIS CELL
"""
%matplotlib inline
import os
from glob import glob
from matplotlib import pyplot

mnist_images = helper.get_batch(glob(os.path.join(data_dir, 'mnist/*.jpg'))[:show_n_images], 28, 28, 'L')
pyplot.imshow(helper.images_square_grid(mnist_images, 'L'), cmap='gray')

<matplotlib.image.AxesImage at 0x7f651686f048>

CelebA¶

The CelebFaces Attributes Dataset (CelebA) dataset contains over 200,000 celebrity images with annotations. Since you're going to be generating faces, you won't need the annotations. You can view the first number of examples by changing show_n_images.

show_n_images = 25

"""
DON'T MODIFY ANYTHING IN THIS CELL
"""
mnist_images = helper.get_batch(glob(os.path.join(data_dir, 'img_align_celeba/*.jpg'))[:show_n_images], 28, 28, 'RGB')
pyplot.imshow(helper.images_square_grid(mnist_images, 'RGB'))

<matplotlib.image.AxesImage at 0x7f6524fe0b00>

Preprocess the Data¶

Since the project's main focus is on building the GANs, we'll preprocess the data for you. The values of the MNIST and CelebA dataset will be in the range of -0.5 to 0.5 of 28x28 dimensional images. The CelebA images will be cropped to remove parts of the image that don't include a face, then resized down to 28x28.

The MNIST images are black and white images with a single color channel while the CelebA images have 3 color channels (RGB color channel).

Build the Neural Network¶

You'll build the components necessary to build a GANs by implementing the following functions below:

model_inputs
discriminator
generator
model_loss
model_opt
train

Check the Version of TensorFlow and Access to GPU¶

This will check to make sure you have the correct version of TensorFlow and access to a GPU

"""
DON'T MODIFY ANYTHING IN THIS CELL
"""
from distutils.version import LooseVersion
import warnings
import tensorflow as tf

# Check TensorFlow Version
assert LooseVersion(tf.__version__) >= LooseVersion('1.0'), 'Please use TensorFlow version 1.0 or newer.  You are using {}'.format(tf.__version__)
print('TensorFlow Version: {}'.format(tf.__version__))

# Check for a GPU
if not tf.test.gpu_device_name():
    warnings.warn('No GPU found. Please use a GPU to train your neural network.')
else:
    print('Default GPU Device: {}'.format(tf.test.gpu_device_name()))

TensorFlow Version: 1.1.0
Default GPU Device: /gpu:0

Input¶

Implement the model_inputs function to create TF Placeholders for the Neural Network. It should create the following placeholders:

Real input images placeholder with rank 4 using image_width, image_height, and image_channels.
Z input placeholder with rank 2 using z_dim.
Learning rate placeholder with rank 0.

Return the placeholders in the following the tuple (tensor of real input images, tensor of z data)

import problem_unittests as tests

def model_inputs(image_width, image_height, image_channels, z_dim):
    """
    Create the model inputs
    :param image_width: The input image width
    :param image_height: The input image height
    :param image_channels: The number of image channels
    :param z_dim: The dimension of Z
    :return: Tuple of (tensor of real input images, tensor of z data, learning rate)
    """
    # TODO: Implement Function
    real_input_images = tf.placeholder(dtype=tf.float32,shape = [None,image_width,image_height,image_channels])
    z_data = tf.placeholder(dtype=tf.float32,shape = [None,z_dim])
    lr = tf.placeholder(dtype=tf.float32,name="learning_rate")
    return real_input_images, z_data, lr


"""
DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
"""
tests.test_model_inputs(model_inputs)

Tests Passed

Discriminator¶

Implement discriminator to create a discriminator neural network that discriminates on images. This function should be able to reuse the variables in the neural network. Use tf.variable_scope with a scope name of "discriminator" to allow the variables to be reused. The function should return a tuple of (tensor output of the discriminator, tensor logits of the discriminator).

def discriminator(images, reuse=False,alpha = 0.2):
    """
    Create the discriminator network
    :param images: Tensor of input image(s)
    :param reuse: Boolean if the weights should be reused
    :return: Tuple of (tensor output of the discriminator, tensor logits of the discriminator)
    """
    # TODO: Implement Function
    
    xav_init = tf.contrib.layers.xavier_initializer()
    with tf.variable_scope("discriminator", reuse=reuse):
        # Input layer is 32x32x3
        x1 = tf.layers.conv2d(images, 64, 5, strides=2, padding='same')
        relu1 = tf.maximum(alpha * x1, x1)
        # 16x16x64
        
        x2 = tf.layers.conv2d(relu1, 128, 5, strides=2, padding='same')
        bn2 = tf.layers.batch_normalization(x2, training=True)
        relu2 = tf.maximum(alpha * bn2, bn2)
        # 8x8x128
        
        x3 = tf.layers.conv2d(relu2, 256, 5, strides=2, padding='same')
        bn3 = tf.layers.batch_normalization(x3, training=True)
        relu3 = tf.maximum(alpha * bn3, bn3)
        # 4x4x256

        # Flatten it
        flat = tf.reshape(relu3, (-1, 4*4*256))
        logits = tf.layers.dense(flat, 1)
        out = tf.sigmoid(logits)
        
        return out, logits


"""
DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
"""
tests.test_discriminator(discriminator, tf)

Tests Passed

Generator¶

Implement generator to generate an image using z. This function should be able to reuse the variables in the neural network. Use tf.variable_scope with a scope name of "generator" to allow the variables to be reused. The function should return the generated 28 x 28 x out_channel_dim images.

def generator(z, out_channel_dim, is_train=True,alpha = 0.20):
    """
    Create the generator network
    :param z: Input z
    :param out_channel_dim: The number of channels in the output image
    :param is_train: Boolean if generator is being used for training
    :return: The tensor output of the generator
    """
    # TODO: Implement Function
    reuse_state = not is_train
    xav = tf.contrib.layers.xavier_initializer()
    
    with tf.variable_scope('generator', reuse=reuse_state):
         # First fully connected layer
        x1 = tf.layers.dense(z, 4*4*256)
        # Reshape it to start the convolutional stack
        x1 = tf.reshape(x1, (-1, 4, 4, 256))
        x1 = tf.layers.batch_normalization(x1, training=is_train)
        x1 = tf.maximum(alpha * x1, x1)
        # print(x1.shape)
        # 4x4x256 now
        #change from 5 to 4 below
        x2 = tf.layers.conv2d_transpose(x1, 128, 4, strides=1, padding='valid', kernel_initializer=xav)
        x2 = tf.layers.batch_normalization(x2, training=is_train)
        x2 = tf.maximum(alpha * x2, x2)
        # print(x2.shape)
        # 7x7x128 now
        
        x3 = tf.layers.conv2d_transpose(x2, 64, 5, strides=2, padding='same', kernel_initializer=xav)
        x3 = tf.layers.batch_normalization(x3, training=is_train)
        x3 = tf.maximum(alpha * x3, x3)
        # print(x3.shape)
        # 14x14x64 now
        
        # Output layer
        logits = tf.layers.conv2d_transpose(x3, out_channel_dim, 5, strides=2, padding='same', kernel_initializer=xav)
        # print(logits.shape)
        # 28x28x5 now
        
        out = tf.tanh(logits)
        
        return out

"""
DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
"""
tests.test_generator(generator, tf)

Tests Passed

Loss¶

Implement model_loss to build the GANs for training and calculate the loss. The function should return a tuple of (discriminator loss, generator loss). Use the following functions you implemented:

discriminator(images, reuse=False)
generator(z, out_channel_dim, is_train=True)

def model_loss(input_real, input_z, out_channel_dim, alpha = 0.2):
    """
    Get the loss for the discriminator and generator
    :param input_real: Images from the real dataset
    :param input_z: Z input
    :param out_channel_dim: The number of channels in the output image
    :return: A tuple of (discriminator loss, generator loss)
    """
    # TODO: Implement Function
    g_model = generator(input_z, out_channel_dim, alpha=alpha)
    d_model_real, d_logits_real = discriminator(input_real, alpha=alpha)
    d_model_fake, d_logits_fake = discriminator(g_model, reuse=True, alpha=alpha)

    d_loss_real = tf.reduce_mean(
        tf.nn.sigmoid_cross_entropy_with_logits(logits=d_logits_real, labels=tf.ones_like(d_model_real)))
    d_loss_fake = tf.reduce_mean(
        tf.nn.sigmoid_cross_entropy_with_logits(logits=d_logits_fake, labels=tf.zeros_like(d_model_fake)))
    g_loss = tf.reduce_mean(
        tf.nn.sigmoid_cross_entropy_with_logits(logits=d_logits_fake, labels=tf.ones_like(d_model_fake)))

    d_loss = d_loss_real + d_loss_fake

    return d_loss, g_loss

Optimization¶

Implement model_opt to create the optimization operations for the GANs. Use tf.trainable_variables to get all the trainable variables. Filter the variables with names that are in the discriminator and generator scope names. The function should return a tuple of (discriminator training operation, generator training operation).

def model_opt(d_loss, g_loss, learning_rate, beta1):
    """
    Get optimization operations
    :param d_loss: Discriminator loss Tensor
    :param g_loss: Generator loss Tensor
    :param learning_rate: Learning Rate Placeholder
    :param beta1: The exponential decay rate for the 1st moment in the optimizer
    :return: A tuple of (discriminator training operation, generator training operation)
    """
    # TODO: Implement Function
    t_vars = tf.trainable_variables()
    d_vars = [var for var in t_vars if var.name.startswith('discriminator')]
    g_vars = [var for var in t_vars if var.name.startswith('generator')]

    # Optimize
    with tf.control_dependencies(tf.get_collection(tf.GraphKeys.UPDATE_OPS)):
        d_train_opt = tf.train.AdamOptimizer(learning_rate, beta1=beta1).minimize(d_loss, var_list=d_vars)
        g_train_opt = tf.train.AdamOptimizer(learning_rate, beta1=beta1).minimize(g_loss, var_list=g_vars)

    return d_train_opt, g_train_opt


"""
DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
"""
tests.test_model_opt(model_opt, tf)

Tests Passed

Neural Network Training¶

Show Output¶

Use this function to show the current output of the generator during training. It will help you determine how well the GANs is training.

"""
DON'T MODIFY ANYTHING IN THIS CELL
"""
import numpy as np

def show_generator_output(sess, n_images, input_z, out_channel_dim, image_mode):
    """
    Show example output for the generator
    :param sess: TensorFlow session
    :param n_images: Number of Images to display
    :param input_z: Input Z Tensor
    :param out_channel_dim: The number of channels in the output image
    :param image_mode: The mode to use for images ("RGB" or "L")
    """
    cmap = None if image_mode == 'RGB' else 'gray'
    z_dim = input_z.get_shape().as_list()[-1]
    example_z = np.random.uniform(-1, 1, size=[n_images, z_dim])

    samples = sess.run(
        generator(input_z, out_channel_dim, False),
        feed_dict={input_z: example_z})

    images_grid = helper.images_square_grid(samples, image_mode)
    pyplot.imshow(images_grid, cmap=cmap)
    pyplot.show()

Train¶

Implement train to build and train the GANs. Use the following functions you implemented:

model_inputs(image_width, image_height, image_channels, z_dim)
model_loss(input_real, input_z, out_channel_dim)
model_opt(d_loss, g_loss, learning_rate, beta1)

Use the show_generator_output to show generator output while you train. Running show_generator_output for every batch will drastically increase training time and increase the size of the notebook. It's recommended to print the generator output every 100 batches.

def train(epoch_count, batch_size, z_dim, learning_rate, beta1, get_batches, data_shape, data_image_mode):
    """
    Train the GAN
    :param epoch_count: Number of epochs
    :param batch_size: Batch Size
    :param z_dim: Z dimension
    :param learning_rate: Learning Rate
    :param beta1: The exponential decay rate for the 1st moment in the optimizer
    :param get_batches: Function to get batches
    :param data_shape: Shape of the data
    :param data_image_mode: The image mode to use for images ("RGB" or "L")
    """
    # TODO: Build Model
    _, img_height, img_width, img_channel = data_shape    
    inputs_real, inputs_z, lr = model_inputs(img_height, img_width, img_channel, z_dim)
    
    d_loss, g_loss = model_loss(inputs_real, inputs_z, img_channel)
    d_opt, g_opt = model_opt(d_loss, g_loss, lr, beta1)
    
    losses = []
    steps = 0
    
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        for epoch_i in range(epoch_count):
            for batch_images in get_batches(batch_size):
                # TODO: Train Model
                steps += 1
                
                # Convert the images values from -.5, .5 to -1, 1
                batch_images *= 2
                
                batch_z = np.random.uniform(-1, 1, size=[batch_size, z_dim])
                
                # Run optimizers
                sess.run(d_opt, feed_dict={inputs_real: batch_images, inputs_z: batch_z, lr: learning_rate})
                sess.run(g_opt, feed_dict={inputs_real: batch_images, inputs_z: batch_z, lr: learning_rate})
                                
                # Show the loss every 10 steps
                if steps % 10 == 0:
                    train_loss_d = d_loss.eval({inputs_real: batch_images, inputs_z: batch_z})
                    train_loss_g = g_loss.eval({inputs_z: batch_z})
                    
                    print('Epoch: {}/{}'.format(epoch_i + 1, epoch_count),
                          'Discriminator Loss: {}'.format(train_loss_d),
                          'Generator Loss: {}'.format(train_loss_g))
                    
                    # Save the losses to view after training
                    losses.append((train_loss_d, train_loss_g))
                
                # Show the generator ouput every 100 steps
                if steps % 100 == 0:
                    show_generator_output(sess, 25, inputs_z, data_shape[3], data_image_mode)
    
    return losses

MNIST¶

Test your GANs architecture on MNIST. After 2 epochs, the GANs should be able to generate images that look like handwritten digits. Make sure the loss of the generator is lower than the loss of the discriminator or close to 0.

batch_size = 32
z_dim = 100
learning_rate = 0.0005
beta1 = 0.5


"""
DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
"""
epochs = 2

mnist_dataset = helper.Dataset('mnist', glob(os.path.join(data_dir, 'mnist/*.jpg')))
with tf.Graph().as_default():
    train(epochs, batch_size, z_dim, learning_rate, beta1, mnist_dataset.get_batches,
          mnist_dataset.shape, mnist_dataset.image_mode)

Epoch: 1/2 Discriminator Loss: 0.13713344931602478 Generator Loss: 2.1663877964019775
Epoch: 1/2 Discriminator Loss: 0.014591054990887642 Generator Loss: 11.815010070800781
Epoch: 1/2 Discriminator Loss: 0.17261575162410736 Generator Loss: 16.79720687866211
Epoch: 1/2 Discriminator Loss: 0.02213411033153534 Generator Loss: 4.110032558441162
Epoch: 1/2 Discriminator Loss: 0.00024479455896653235 Generator Loss: 12.366539001464844
Epoch: 1/2 Discriminator Loss: 0.004800793714821339 Generator Loss: 9.397963523864746
Epoch: 1/2 Discriminator Loss: 1.4637947082519531 Generator Loss: 0.3298260569572449
Epoch: 1/2 Discriminator Loss: 0.8907942175865173 Generator Loss: 17.771806716918945
Epoch: 1/2 Discriminator Loss: 0.35442060232162476 Generator Loss: 1.7113244533538818
Epoch: 1/2 Discriminator Loss: 1.052382230758667 Generator Loss: 0.9694688320159912

Epoch: 1/2 Discriminator Loss: 0.5298925638198853 Generator Loss: 3.7039260864257812
Epoch: 1/2 Discriminator Loss: 0.21832074224948883 Generator Loss: 2.3501152992248535
Epoch: 1/2 Discriminator Loss: 0.06110001355409622 Generator Loss: 3.5117053985595703
Epoch: 1/2 Discriminator Loss: 0.06429081410169601 Generator Loss: 6.969024181365967
Epoch: 1/2 Discriminator Loss: 1.2863349914550781 Generator Loss: 13.199653625488281
Epoch: 1/2 Discriminator Loss: 0.3337439000606537 Generator Loss: 1.6589585542678833
Epoch: 1/2 Discriminator Loss: 0.809114933013916 Generator Loss: 2.7894630432128906
Epoch: 1/2 Discriminator Loss: 0.45783671736717224 Generator Loss: 1.7317280769348145
Epoch: 1/2 Discriminator Loss: 0.4052000641822815 Generator Loss: 2.4619834423065186
Epoch: 1/2 Discriminator Loss: 0.4687625467777252 Generator Loss: 1.412057876586914

Epoch: 1/2 Discriminator Loss: 0.3424420952796936 Generator Loss: 1.8369191884994507
Epoch: 1/2 Discriminator Loss: 0.11490097641944885 Generator Loss: 3.5756633281707764
Epoch: 1/2 Discriminator Loss: 0.6536540389060974 Generator Loss: 1.680572748184204
Epoch: 1/2 Discriminator Loss: 1.0748546123504639 Generator Loss: 1.1720201969146729
Epoch: 1/2 Discriminator Loss: 0.4702276885509491 Generator Loss: 1.8193504810333252
Epoch: 1/2 Discriminator Loss: 0.21666303277015686 Generator Loss: 3.729619026184082
Epoch: 1/2 Discriminator Loss: 0.39896360039711 Generator Loss: 3.2033944129943848
Epoch: 1/2 Discriminator Loss: 0.462210476398468 Generator Loss: 1.7327914237976074
Epoch: 1/2 Discriminator Loss: 0.9704363346099854 Generator Loss: 1.0686891078948975
Epoch: 1/2 Discriminator Loss: 0.5541753172874451 Generator Loss: 2.8244240283966064

Epoch: 1/2 Discriminator Loss: 0.8076108694076538 Generator Loss: 1.1785006523132324
Epoch: 1/2 Discriminator Loss: 0.4004136323928833 Generator Loss: 1.7758426666259766
Epoch: 1/2 Discriminator Loss: 1.2083594799041748 Generator Loss: 0.9206530451774597
Epoch: 1/2 Discriminator Loss: 0.740831732749939 Generator Loss: 1.6430861949920654
Epoch: 1/2 Discriminator Loss: 0.6303328275680542 Generator Loss: 1.3862309455871582
Epoch: 1/2 Discriminator Loss: 1.4960100650787354 Generator Loss: 0.42912590503692627
Epoch: 1/2 Discriminator Loss: 0.7935053110122681 Generator Loss: 1.1468439102172852
Epoch: 1/2 Discriminator Loss: 0.6719897389411926 Generator Loss: 1.0895562171936035
Epoch: 1/2 Discriminator Loss: 0.7097548842430115 Generator Loss: 1.9330439567565918
Epoch: 1/2 Discriminator Loss: 1.0198278427124023 Generator Loss: 0.8417806625366211

Epoch: 1/2 Discriminator Loss: 0.5182974934577942 Generator Loss: 2.5293493270874023
Epoch: 1/2 Discriminator Loss: 0.4419874846935272 Generator Loss: 1.8683452606201172
Epoch: 1/2 Discriminator Loss: 1.789455533027649 Generator Loss: 0.2775825560092926
Epoch: 1/2 Discriminator Loss: 0.9458807706832886 Generator Loss: 0.7131125926971436
Epoch: 1/2 Discriminator Loss: 1.157063603401184 Generator Loss: 0.5674276351928711
Epoch: 1/2 Discriminator Loss: 0.615569531917572 Generator Loss: 2.399745464324951
Epoch: 1/2 Discriminator Loss: 0.8311426639556885 Generator Loss: 2.7880959510803223
Epoch: 1/2 Discriminator Loss: 0.8878272175788879 Generator Loss: 1.302507758140564
Epoch: 1/2 Discriminator Loss: 0.5968215465545654 Generator Loss: 2.0619380474090576
Epoch: 1/2 Discriminator Loss: 0.9856685400009155 Generator Loss: 3.3230514526367188

Epoch: 1/2 Discriminator Loss: 0.5651271939277649 Generator Loss: 1.703908085823059
Epoch: 1/2 Discriminator Loss: 1.1688774824142456 Generator Loss: 0.5951809883117676
Epoch: 1/2 Discriminator Loss: 1.3435943126678467 Generator Loss: 0.47657519578933716
Epoch: 1/2 Discriminator Loss: 0.6241391897201538 Generator Loss: 1.4033918380737305
Epoch: 1/2 Discriminator Loss: 0.7374500036239624 Generator Loss: 1.0027881860733032
Epoch: 1/2 Discriminator Loss: 0.722841739654541 Generator Loss: 1.3248766660690308
Epoch: 1/2 Discriminator Loss: 0.9330260157585144 Generator Loss: 0.8334124088287354
Epoch: 1/2 Discriminator Loss: 0.6774267554283142 Generator Loss: 2.343909740447998
Epoch: 1/2 Discriminator Loss: 1.1781542301177979 Generator Loss: 3.8526973724365234
Epoch: 1/2 Discriminator Loss: 1.413313627243042 Generator Loss: 0.431384801864624

Epoch: 1/2 Discriminator Loss: 0.6947544813156128 Generator Loss: 1.4076586961746216
Epoch: 1/2 Discriminator Loss: 1.3539539575576782 Generator Loss: 0.5386990308761597
Epoch: 1/2 Discriminator Loss: 0.9242820739746094 Generator Loss: 1.9370675086975098
Epoch: 1/2 Discriminator Loss: 1.093009114265442 Generator Loss: 3.503354072570801
Epoch: 1/2 Discriminator Loss: 0.9032994508743286 Generator Loss: 0.7594524025917053
Epoch: 1/2 Discriminator Loss: 0.704890251159668 Generator Loss: 1.5861709117889404
Epoch: 1/2 Discriminator Loss: 0.5234852433204651 Generator Loss: 1.7586688995361328
Epoch: 1/2 Discriminator Loss: 0.8510828614234924 Generator Loss: 1.1310657262802124
Epoch: 1/2 Discriminator Loss: 0.6991603374481201 Generator Loss: 1.0804352760314941
Epoch: 1/2 Discriminator Loss: 0.9425098299980164 Generator Loss: 0.7205004692077637

Epoch: 1/2 Discriminator Loss: 0.8629515171051025 Generator Loss: 1.6171307563781738
Epoch: 1/2 Discriminator Loss: 1.4284398555755615 Generator Loss: 0.4156547784805298
Epoch: 1/2 Discriminator Loss: 0.7170894145965576 Generator Loss: 1.231532335281372
Epoch: 1/2 Discriminator Loss: 0.7110718488693237 Generator Loss: 2.7318718433380127
Epoch: 1/2 Discriminator Loss: 0.9291354417800903 Generator Loss: 0.747428834438324
Epoch: 1/2 Discriminator Loss: 0.7903684377670288 Generator Loss: 1.5473212003707886
Epoch: 1/2 Discriminator Loss: 0.6597652435302734 Generator Loss: 1.3573687076568604
Epoch: 1/2 Discriminator Loss: 0.8369518518447876 Generator Loss: 0.9803171753883362
Epoch: 1/2 Discriminator Loss: 0.650047779083252 Generator Loss: 1.817121982574463
Epoch: 1/2 Discriminator Loss: 0.5731419324874878 Generator Loss: 2.1540427207946777

Epoch: 1/2 Discriminator Loss: 1.3937945365905762 Generator Loss: 3.1843345165252686
Epoch: 1/2 Discriminator Loss: 1.3309279680252075 Generator Loss: 0.48775455355644226
Epoch: 1/2 Discriminator Loss: 0.9024871587753296 Generator Loss: 0.8931524157524109
Epoch: 1/2 Discriminator Loss: 0.756559431552887 Generator Loss: 1.4703574180603027
Epoch: 1/2 Discriminator Loss: 0.5951460599899292 Generator Loss: 2.2924606800079346
Epoch: 1/2 Discriminator Loss: 0.7849414348602295 Generator Loss: 0.8679742217063904
Epoch: 1/2 Discriminator Loss: 1.2128257751464844 Generator Loss: 0.5162991285324097
Epoch: 1/2 Discriminator Loss: 0.9164903163909912 Generator Loss: 0.7201865911483765
Epoch: 1/2 Discriminator Loss: 0.8609462976455688 Generator Loss: 1.131991982460022
Epoch: 1/2 Discriminator Loss: 0.9265981316566467 Generator Loss: 0.8130074739456177

Epoch: 1/2 Discriminator Loss: 0.7934618592262268 Generator Loss: 0.9492272734642029
Epoch: 1/2 Discriminator Loss: 0.9352329969406128 Generator Loss: 0.7170085906982422
Epoch: 1/2 Discriminator Loss: 1.5692853927612305 Generator Loss: 0.4112204909324646
Epoch: 1/2 Discriminator Loss: 0.8138118982315063 Generator Loss: 1.37114417552948
Epoch: 1/2 Discriminator Loss: 0.9875728487968445 Generator Loss: 0.7335025072097778
Epoch: 1/2 Discriminator Loss: 0.8425469398498535 Generator Loss: 2.327805757522583
Epoch: 1/2 Discriminator Loss: 0.8034218549728394 Generator Loss: 0.934604287147522
Epoch: 1/2 Discriminator Loss: 1.1497365236282349 Generator Loss: 0.570300817489624
Epoch: 1/2 Discriminator Loss: 0.5970398783683777 Generator Loss: 1.6708873510360718
Epoch: 1/2 Discriminator Loss: 0.6087714433670044 Generator Loss: 2.2014029026031494

CelebA¶

Run your GANs on CelebA. It will take around 20 minutes on the average GPU to run one epoch. You can run the whole epoch or stop when it starts to generate realistic faces.

batch_size = 16
z_dim = 100
learning_rate = 0.001
beta1 = 0.5


"""
DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
"""
epochs = 1

celeba_dataset = helper.Dataset('celeba', glob(os.path.join(data_dir, 'img_align_celeba/*.jpg')))
with tf.Graph().as_default():
    train(epochs, batch_size, z_dim, learning_rate, beta1, celeba_dataset.get_batches,
          celeba_dataset.shape, celeba_dataset.image_mode)

Epoch: 1/1 Discriminator Loss: 10.810354232788086 Generator Loss: 8.428108412772417e-05
Epoch: 1/1 Discriminator Loss: 0.31975671648979187 Generator Loss: 1.600989818572998
Epoch: 1/1 Discriminator Loss: 0.5855777263641357 Generator Loss: 18.779287338256836
Epoch: 1/1 Discriminator Loss: 2.489269733428955 Generator Loss: 19.768108367919922
Epoch: 1/1 Discriminator Loss: 0.13270355761051178 Generator Loss: 2.83123779296875
Epoch: 1/1 Discriminator Loss: 0.008803030475974083 Generator Loss: 9.702881813049316
Epoch: 1/1 Discriminator Loss: 1.7682198286056519 Generator Loss: 12.55789852142334
Epoch: 1/1 Discriminator Loss: 0.029099686071276665 Generator Loss: 4.723364353179932
Epoch: 1/1 Discriminator Loss: 0.13555245101451874 Generator Loss: 7.76912784576416
Epoch: 1/1 Discriminator Loss: 0.27598950266838074 Generator Loss: 2.0219080448150635

Epoch: 1/1 Discriminator Loss: 0.5200375318527222 Generator Loss: 9.29719066619873
Epoch: 1/1 Discriminator Loss: 3.170954942703247 Generator Loss: 0.06716036051511765
Epoch: 1/1 Discriminator Loss: 0.7705772519111633 Generator Loss: 6.8452887535095215
Epoch: 1/1 Discriminator Loss: 0.3632393479347229 Generator Loss: 2.7438149452209473
Epoch: 1/1 Discriminator Loss: 0.9805972576141357 Generator Loss: 8.155176162719727
Epoch: 1/1 Discriminator Loss: 0.8909600973129272 Generator Loss: 1.1680126190185547
Epoch: 1/1 Discriminator Loss: 0.7460823655128479 Generator Loss: 0.7798707485198975
Epoch: 1/1 Discriminator Loss: 0.3996647298336029 Generator Loss: 1.4830493927001953
Epoch: 1/1 Discriminator Loss: 0.06461276113986969 Generator Loss: 5.267812728881836
Epoch: 1/1 Discriminator Loss: 0.15054981410503387 Generator Loss: 2.6583218574523926

Epoch: 1/1 Discriminator Loss: 0.16159066557884216 Generator Loss: 3.373105525970459
Epoch: 1/1 Discriminator Loss: 0.11206991970539093 Generator Loss: 3.4719762802124023
Epoch: 1/1 Discriminator Loss: 0.5514494776725769 Generator Loss: 1.2371572256088257
Epoch: 1/1 Discriminator Loss: 2.808454990386963 Generator Loss: 0.13185052573680878
Epoch: 1/1 Discriminator Loss: 0.2767036259174347 Generator Loss: 2.6791789531707764
Epoch: 1/1 Discriminator Loss: 0.6312674283981323 Generator Loss: 1.600643277168274
Epoch: 1/1 Discriminator Loss: 0.7999053001403809 Generator Loss: 7.7624359130859375
Epoch: 1/1 Discriminator Loss: 0.5350130796432495 Generator Loss: 1.2562516927719116
Epoch: 1/1 Discriminator Loss: 0.4393993020057678 Generator Loss: 1.4233067035675049
Epoch: 1/1 Discriminator Loss: 1.655874490737915 Generator Loss: 0.3225424885749817

Epoch: 1/1 Discriminator Loss: 0.736802339553833 Generator Loss: 1.3840161561965942
Epoch: 1/1 Discriminator Loss: 0.7482905387878418 Generator Loss: 1.065515160560608
Epoch: 1/1 Discriminator Loss: 0.9832556247711182 Generator Loss: 3.279715061187744
Epoch: 1/1 Discriminator Loss: 0.7604594230651855 Generator Loss: 1.0447118282318115
Epoch: 1/1 Discriminator Loss: 0.9879684448242188 Generator Loss: 1.1223375797271729
Epoch: 1/1 Discriminator Loss: 0.536897599697113 Generator Loss: 1.7224462032318115
Epoch: 1/1 Discriminator Loss: 1.2454049587249756 Generator Loss: 0.5006133913993835
Epoch: 1/1 Discriminator Loss: 1.9776890277862549 Generator Loss: 0.3146326541900635
Epoch: 1/1 Discriminator Loss: 0.7685585618019104 Generator Loss: 0.8482518792152405
Epoch: 1/1 Discriminator Loss: 1.3506858348846436 Generator Loss: 2.1708853244781494

Epoch: 1/1 Discriminator Loss: 1.0607796907424927 Generator Loss: 2.7296600341796875
Epoch: 1/1 Discriminator Loss: 1.345637321472168 Generator Loss: 0.6252953410148621
Epoch: 1/1 Discriminator Loss: 0.8765450119972229 Generator Loss: 0.9438919425010681
Epoch: 1/1 Discriminator Loss: 0.8514735102653503 Generator Loss: 0.8311397433280945
Epoch: 1/1 Discriminator Loss: 0.3985252380371094 Generator Loss: 2.3220255374908447
Epoch: 1/1 Discriminator Loss: 1.2301528453826904 Generator Loss: 0.6206825971603394
Epoch: 1/1 Discriminator Loss: 0.3773060739040375 Generator Loss: 2.8953676223754883
Epoch: 1/1 Discriminator Loss: 0.14604775607585907 Generator Loss: 4.424351692199707
Epoch: 1/1 Discriminator Loss: 0.04934397712349892 Generator Loss: 4.286716461181641
Epoch: 1/1 Discriminator Loss: 2.8125247955322266 Generator Loss: 4.092017650604248

Epoch: 1/1 Discriminator Loss: 0.8398771286010742 Generator Loss: 1.3244261741638184
Epoch: 1/1 Discriminator Loss: 1.1957284212112427 Generator Loss: 1.3309907913208008
Epoch: 1/1 Discriminator Loss: 1.303458571434021 Generator Loss: 0.5269277095794678
Epoch: 1/1 Discriminator Loss: 2.4662063121795654 Generator Loss: 4.7639923095703125
Epoch: 1/1 Discriminator Loss: 0.35082948207855225 Generator Loss: 2.904829502105713
Epoch: 1/1 Discriminator Loss: 0.3095531463623047 Generator Loss: 1.6519930362701416
Epoch: 1/1 Discriminator Loss: 1.4438127279281616 Generator Loss: 0.5501083135604858
Epoch: 1/1 Discriminator Loss: 0.5829973816871643 Generator Loss: 1.1866133213043213
Epoch: 1/1 Discriminator Loss: 0.8645034432411194 Generator Loss: 0.7843308448791504
Epoch: 1/1 Discriminator Loss: 0.17417970299720764 Generator Loss: 2.2163076400756836

Epoch: 1/1 Discriminator Loss: 0.7674451470375061 Generator Loss: 1.2347617149353027
Epoch: 1/1 Discriminator Loss: 0.8242056369781494 Generator Loss: 0.9487175941467285
Epoch: 1/1 Discriminator Loss: 0.4816313683986664 Generator Loss: 1.7069838047027588
Epoch: 1/1 Discriminator Loss: 0.6766893863677979 Generator Loss: 1.0993518829345703
Epoch: 1/1 Discriminator Loss: 0.6635744571685791 Generator Loss: 1.0659348964691162
Epoch: 1/1 Discriminator Loss: 0.6802875399589539 Generator Loss: 1.1014633178710938
Epoch: 1/1 Discriminator Loss: 0.3171601891517639 Generator Loss: 1.7499423027038574
Epoch: 1/1 Discriminator Loss: 0.05632389336824417 Generator Loss: 4.933645248413086
Epoch: 1/1 Discriminator Loss: 0.15607818961143494 Generator Loss: 3.517049789428711
Epoch: 1/1 Discriminator Loss: 0.08436628431081772 Generator Loss: 4.492081642150879

Epoch: 1/1 Discriminator Loss: 0.6466320753097534 Generator Loss: 3.1230640411376953
Epoch: 1/1 Discriminator Loss: 0.8671048879623413 Generator Loss: 1.323126196861267
Epoch: 1/1 Discriminator Loss: 0.5259050130844116 Generator Loss: 2.307889223098755
Epoch: 1/1 Discriminator Loss: 0.737124502658844 Generator Loss: 1.3028768301010132
Epoch: 1/1 Discriminator Loss: 0.46579504013061523 Generator Loss: 2.7246546745300293
Epoch: 1/1 Discriminator Loss: 0.6642292737960815 Generator Loss: 1.2948102951049805
Epoch: 1/1 Discriminator Loss: 1.968140721321106 Generator Loss: 0.2537706196308136
Epoch: 1/1 Discriminator Loss: 0.6031506061553955 Generator Loss: 1.7280540466308594
Epoch: 1/1 Discriminator Loss: 0.25914689898490906 Generator Loss: 1.9181984663009644
Epoch: 1/1 Discriminator Loss: 0.02873225137591362 Generator Loss: 5.122189044952393

Epoch: 1/1 Discriminator Loss: 0.7202461361885071 Generator Loss: 4.2536492347717285
Epoch: 1/1 Discriminator Loss: 0.3299497663974762 Generator Loss: 4.315952301025391
Epoch: 1/1 Discriminator Loss: 0.24362069368362427 Generator Loss: 4.376984119415283
Epoch: 1/1 Discriminator Loss: 0.11905550956726074 Generator Loss: 3.765374183654785
Epoch: 1/1 Discriminator Loss: 4.065575122833252 Generator Loss: 0.03191173076629639
Epoch: 1/1 Discriminator Loss: 0.40909481048583984 Generator Loss: 1.762511134147644
Epoch: 1/1 Discriminator Loss: 0.25234049558639526 Generator Loss: 4.0047101974487305
Epoch: 1/1 Discriminator Loss: 1.4182143211364746 Generator Loss: 0.7088556885719299
Epoch: 1/1 Discriminator Loss: 1.0336192846298218 Generator Loss: 0.924479067325592
Epoch: 1/1 Discriminator Loss: 0.8136768341064453 Generator Loss: 0.9428712129592896

Epoch: 1/1 Discriminator Loss: 0.5202776789665222 Generator Loss: 6.25490140914917
Epoch: 1/1 Discriminator Loss: 0.48623406887054443 Generator Loss: 1.1666274070739746
Epoch: 1/1 Discriminator Loss: 0.9627767205238342 Generator Loss: 1.1671199798583984
Epoch: 1/1 Discriminator Loss: 0.8350054025650024 Generator Loss: 0.7575980424880981
Epoch: 1/1 Discriminator Loss: 0.07812411338090897 Generator Loss: 3.347412347793579
Epoch: 1/1 Discriminator Loss: 0.8969031572341919 Generator Loss: 0.7116981744766235
Epoch: 1/1 Discriminator Loss: 0.10693423449993134 Generator Loss: 4.013042449951172
Epoch: 1/1 Discriminator Loss: 0.08722518384456635 Generator Loss: 4.689572334289551
Epoch: 1/1 Discriminator Loss: 0.05538773536682129 Generator Loss: 6.412632942199707
Epoch: 1/1 Discriminator Loss: 0.7119020819664001 Generator Loss: 1.3260166645050049

Submitting This Project¶

When submitting this project, make sure to run all the cells before saving the notebook. Save the notebook file as "dlnd_face_generation.ipynb" and save it as a HTML file under "File" -> "Download as". Include the "helper.py" and "problem_unittests.py" files in your submission.